/**
 * jscolor - JavaScript Color Picker
 *
 * @link    http://jscolor.com
 * @license For open source use: GPLv3
 *          For commercial use: JSColor Commercial License
 * @author  Jan Odvarko
 * @version 2.0.4
 *
 * See usage examples at http://jscolor.com/examples/
 */

"use strict";

if (!window.jscolor) {
  window.jscolor = (function() {
    var jsc = {
      register: function() {
        jsc.attachDOMReadyEvent(jsc.init);
        jsc.attachEvent(document, "mousedown", jsc.onDocumentMouseDown);
        jsc.attachEvent(document, "touchstart", jsc.onDocumentTouchStart);
        jsc.attachEvent(window, "resize", jsc.onWindowResize);
      },

      init: function() {
        if (jsc.jscolor.lookupClass) {
          jsc.jscolor.installByClassName(jsc.jscolor.lookupClass);
        }
      },

      tryInstallOnElements: function(elms, className) {
        var matchClass = new RegExp("(^|\\s)(" + className + ")(\\s*(\\{[^}]*\\})|\\s|$)", "i");

        for (var i = 0; i < elms.length; i += 1) {
          if (elms[i].type !== undefined && elms[i].type.toLowerCase() == "color") {
            if (jsc.isColorAttrSupported) {
              // skip inputs of type 'color' if supported by the browser
              continue;
            }
          }
          var m;
          if (!elms[i].jscolor && elms[i].className && (m = elms[i].className.match(matchClass))) {
            var targetElm = elms[i];
            var optsStr = null;

            var dataOptions = jsc.getDataAttr(targetElm, "jscolor");
            if (dataOptions !== null) {
              optsStr = dataOptions;
            } else if (m[4]) {
              optsStr = m[4];
            }

            var opts = {};
            if (optsStr) {
              try {
                opts = new Function("return (" + optsStr + ")")();
              } catch (eParseError) {
                jsc.warn("Error parsing jscolor options: " + eParseError + ":\n" + optsStr);
              }
            }
            targetElm.jscolor = new jsc.jscolor(targetElm, opts);
          }
        }
      },

      isColorAttrSupported: (function() {
        var elm = document.createElement("input");
        if (elm.setAttribute) {
          elm.setAttribute("type", "color");
          if (elm.type.toLowerCase() == "color") {
            return true;
          }
        }
        return false;
      })(),

      isCanvasSupported: (function() {
        var elm = document.createElement("canvas");
        return !!(elm.getContext && elm.getContext("2d"));
      })(),

      fetchElement: function(mixed) {
        return typeof mixed === "string" ? document.getElementById(mixed) : mixed;
      },

      isElementType: function(elm, type) {
        return elm.nodeName.toLowerCase() === type.toLowerCase();
      },

      getDataAttr: function(el, name) {
        var attrName = "data-" + name;
        var attrValue = el.getAttribute(attrName);
        if (attrValue !== null) {
          return attrValue;
        }
        return null;
      },

      attachEvent: function(el, evnt, func) {
        if (el.addEventListener) {
          el.addEventListener(evnt, func, false);
        } else if (el.attachEvent) {
          el.attachEvent("on" + evnt, func);
        }
      },

      detachEvent: function(el, evnt, func) {
        if (el.removeEventListener) {
          el.removeEventListener(evnt, func, false);
        } else if (el.detachEvent) {
          el.detachEvent("on" + evnt, func);
        }
      },

      _attachedGroupEvents: {},

      attachGroupEvent: function(groupName, el, evnt, func) {
        if (!jsc._attachedGroupEvents.hasOwnProperty(groupName)) {
          jsc._attachedGroupEvents[groupName] = [];
        }
        jsc._attachedGroupEvents[groupName].push([el, evnt, func]);
        jsc.attachEvent(el, evnt, func);
      },

      detachGroupEvents: function(groupName) {
        if (jsc._attachedGroupEvents.hasOwnProperty(groupName)) {
          for (var i = 0; i < jsc._attachedGroupEvents[groupName].length; i += 1) {
            var evt = jsc._attachedGroupEvents[groupName][i];
            jsc.detachEvent(evt[0], evt[1], evt[2]);
          }
          delete jsc._attachedGroupEvents[groupName];
        }
      },

      attachDOMReadyEvent: function(func) {
        var fired = false;
        var fireOnce = function() {
          if (!fired) {
            fired = true;
            func();
          }
        };

        if (document.readyState === "complete") {
          setTimeout(fireOnce, 1); // async
          return;
        }

        if (document.addEventListener) {
          document.addEventListener("DOMContentLoaded", fireOnce, false);

          // Fallback
          window.addEventListener("load", fireOnce, false);
        } else if (document.attachEvent) {
          // IE
          document.attachEvent("onreadystatechange", function() {
            if (document.readyState === "complete") {
              document.detachEvent("onreadystatechange", arguments.callee);
              fireOnce();
            }
          });

          // Fallback
          window.attachEvent("onload", fireOnce);

          // IE7/8
          if (document.documentElement.doScroll && window == window.top) {
            var tryScroll = function() {
              if (!document.body) {
                return;
              }
              try {
                document.documentElement.doScroll("left");
                fireOnce();
              } catch (e) {
                setTimeout(tryScroll, 1);
              }
            };
            tryScroll();
          }
        }
      },

      warn: function(msg) {
        if (window.console && window.console.warn) {
          window.console.warn(msg);
        }
      },

      preventDefault: function(e) {
        if (e.preventDefault) {
          e.preventDefault();
        }
        e.returnValue = false;
      },

      captureTarget: function(target) {
        // IE
        if (target.setCapture) {
          jsc._capturedTarget = target;
          jsc._capturedTarget.setCapture();
        }
      },

      releaseTarget: function() {
        // IE
        if (jsc._capturedTarget) {
          jsc._capturedTarget.releaseCapture();
          jsc._capturedTarget = null;
        }
      },

      fireEvent: function(el, evnt) {
        if (!el) {
          return;
        }
        if (document.createEvent) {
          var ev = document.createEvent("HTMLEvents");
          ev.initEvent(evnt, true, true);
          el.dispatchEvent(ev);
        } else if (document.createEventObject) {
          var ev = document.createEventObject();
          el.fireEvent("on" + evnt, ev);
        } else if (el["on" + evnt]) {
          // alternatively use the traditional event model
          el["on" + evnt]();
        }
      },

      classNameToList: function(className) {
        return className.replace(/^\s+|\s+$/g, "").split(/\s+/);
      },

      // The className parameter (str) can only contain a single class name
      hasClass: function(elm, className) {
        if (!className) {
          return false;
        }
        return -1 != (" " + elm.className.replace(/\s+/g, " ") + " ").indexOf(" " + className + " ");
      },

      // The className parameter (str) can contain multiple class names separated by whitespace
      setClass: function(elm, className) {
        var classList = jsc.classNameToList(className);
        for (var i = 0; i < classList.length; i += 1) {
          if (!jsc.hasClass(elm, classList[i])) {
            elm.className += (elm.className ? " " : "") + classList[i];
          }
        }
      },

      // The className parameter (str) can contain multiple class names separated by whitespace
      unsetClass: function(elm, className) {
        var classList = jsc.classNameToList(className);
        for (var i = 0; i < classList.length; i += 1) {
          var repl = new RegExp("^\\s*" + classList[i] + "\\s*|" + "\\s*" + classList[i] + "\\s*$|" + "\\s+" + classList[i] + "(\\s+)", "g");
          elm.className = elm.className.replace(repl, "$1");
        }
      },

      getStyle: function(elm) {
        return window.getComputedStyle ? window.getComputedStyle(elm) : elm.currentStyle;
      },

      setStyle: (function() {
        var helper = document.createElement("div");
        var getSupportedProp = function(names) {
          for (var i = 0; i < names.length; i += 1) {
            if (names[i] in helper.style) {
              return names[i];
            }
          }
        };
        var props = {
          borderRadius: getSupportedProp(["borderRadius", "MozBorderRadius", "webkitBorderRadius"]),
          boxShadow: getSupportedProp(["boxShadow", "MozBoxShadow", "webkitBoxShadow"])
        };
        return function(elm, prop, value) {
          switch (prop.toLowerCase()) {
            case "opacity":
              var alphaOpacity = Math.round(parseFloat(value) * 100);
              elm.style.opacity = value;
              elm.style.filter = "alpha(opacity=" + alphaOpacity + ")";
              break;
            default:
              elm.style[props[prop]] = value;
              break;
          }
        };
      })(),

      setBorderRadius: function(elm, value) {
        jsc.setStyle(elm, "borderRadius", value || "0");
      },

      setBoxShadow: function(elm, value) {
        jsc.setStyle(elm, "boxShadow", value || "none");
      },

      getElementPos: function(e, relativeToViewport) {
        var x = 0,
          y = 0;
        var rect = e.getBoundingClientRect();
        x = rect.left;
        y = rect.top;
        if (!relativeToViewport) {
          var viewPos = jsc.getViewPos();
          x += viewPos[0];
          y += viewPos[1];
        }
        return [x, y];
      },

      getElementSize: function(e) {
        return [e.offsetWidth, e.offsetHeight];
      },

      // get pointer's X/Y coordinates relative to viewport
      getAbsPointerPos: function(e) {
        if (!e) {
          e = window.event;
        }
        var x = 0,
          y = 0;
        if (typeof e.changedTouches !== "undefined" && e.changedTouches.length) {
          // touch devices
          x = e.changedTouches[0].clientX;
          y = e.changedTouches[0].clientY;
        } else if (typeof e.clientX === "number") {
          x = e.clientX;
          y = e.clientY;
        }
        return { x: x, y: y };
      },

      // get pointer's X/Y coordinates relative to target element
      getRelPointerPos: function(e) {
        if (!e) {
          e = window.event;
        }
        var target = e.target || e.srcElement;
        var targetRect = target.getBoundingClientRect();

        var x = 0,
          y = 0;

        var clientX = 0,
          clientY = 0;
        if (typeof e.changedTouches !== "undefined" && e.changedTouches.length) {
          // touch devices
          clientX = e.changedTouches[0].clientX;
          clientY = e.changedTouches[0].clientY;
        } else if (typeof e.clientX === "number") {
          clientX = e.clientX;
          clientY = e.clientY;
        }

        x = clientX - targetRect.left;
        y = clientY - targetRect.top;
        return { x: x, y: y };
      },

      getViewPos: function() {
        var doc = document.documentElement;
        return [(window.pageXOffset || doc.scrollLeft) - (doc.clientLeft || 0), (window.pageYOffset || doc.scrollTop) - (doc.clientTop || 0)];
      },

      getViewSize: function() {
        var doc = document.documentElement;
        return [window.innerWidth || doc.clientWidth, window.innerHeight || doc.clientHeight];
      },

      redrawPosition: function() {
        if (jsc.picker && jsc.picker.owner) {
          var thisObj = jsc.picker.owner;

          var tp, vp;

          if (thisObj.fixed) {
            // Fixed elements are positioned relative to viewport,
            // therefore we can ignore the scroll offset
            tp = jsc.getElementPos(thisObj.targetElement, true); // target pos
            vp = [0, 0]; // view pos
          } else {
            tp = jsc.getElementPos(thisObj.targetElement); // target pos
            vp = jsc.getViewPos(); // view pos
          }

          var ts = jsc.getElementSize(thisObj.targetElement); // target size
          var vs = jsc.getViewSize(); // view size
          var ps = jsc.getPickerOuterDims(thisObj); // picker size
          var a, b, c;
          switch (thisObj.position.toLowerCase()) {
            case "left":
              a = 1;
              b = 0;
              c = -1;
              break;
            case "right":
              a = 1;
              b = 0;
              c = 1;
              break;
            case "top":
              a = 0;
              b = 1;
              c = -1;
              break;
            default:
              a = 0;
              b = 1;
              c = 1;
              break;
          }
          var l = (ts[b] + ps[b]) / 2;

          // compute picker position
          if (!thisObj.smartPosition) {
            var pp = [tp[a], tp[b] + ts[b] - l + l * c];
          } else {
            var pp = [
              -vp[a] + tp[a] + ps[a] > vs[a]
                ? -vp[a] + tp[a] + ts[a] / 2 > vs[a] / 2 && tp[a] + ts[a] - ps[a] >= 0 ? tp[a] + ts[a] - ps[a] : tp[a]
                : tp[a],
              -vp[b] + tp[b] + ts[b] + ps[b] - l + l * c > vs[b]
                ? -vp[b] + tp[b] + ts[b] / 2 > vs[b] / 2 && tp[b] + ts[b] - l - l * c >= 0 ? tp[b] + ts[b] - l - l * c : tp[b] + ts[b] - l + l * c
                : tp[b] + ts[b] - l + l * c >= 0 ? tp[b] + ts[b] - l + l * c : tp[b] + ts[b] - l - l * c
            ];
          }

          var x = pp[a];
          var y = pp[b];
          var positionValue = thisObj.fixed ? "fixed" : "absolute";
          var contractShadow = (pp[0] + ps[0] > tp[0] || pp[0] < tp[0] + ts[0]) && pp[1] + ps[1] < tp[1] + ts[1];

          jsc._drawPosition(thisObj, x, y, positionValue, contractShadow);
        }
      },

      _drawPosition: function(thisObj, x, y, positionValue, contractShadow) {
        var vShadow = contractShadow ? 0 : thisObj.shadowBlur; // px

        jsc.picker.wrap.style.position = positionValue;
        jsc.picker.wrap.style.left = x + "px";
        jsc.picker.wrap.style.top = y + "px";

        jsc.setBoxShadow(jsc.picker.boxS, thisObj.shadow ? new jsc.BoxShadow(0, vShadow, thisObj.shadowBlur, 0, thisObj.shadowColor) : null);
      },

      getPickerDims: function(thisObj) {
        var displaySlider = !!jsc.getSliderComponent(thisObj);
        var dims = [
          2 * thisObj.insetWidth +
            2 * thisObj.padding +
            thisObj.width +
            (displaySlider ? 2 * thisObj.insetWidth + jsc.getPadToSliderPadding(thisObj) + thisObj.sliderSize : 0),
          2 * thisObj.insetWidth +
            2 * thisObj.padding +
            thisObj.height +
            (thisObj.closable ? 2 * thisObj.insetWidth + thisObj.padding + thisObj.buttonHeight : 0)
        ];
        return dims;
      },

      getPickerOuterDims: function(thisObj) {
        var dims = jsc.getPickerDims(thisObj);
        return [dims[0] + 2 * thisObj.borderWidth, dims[1] + 2 * thisObj.borderWidth];
      },

      getPadToSliderPadding: function(thisObj) {
        return Math.max(thisObj.padding, 1.5 * (2 * thisObj.pointerBorderWidth + thisObj.pointerThickness));
      },

      getPadYComponent: function(thisObj) {
        switch (thisObj.mode.charAt(1).toLowerCase()) {
          case "v":
            return "v";
            break;
        }
        return "s";
      },

      getSliderComponent: function(thisObj) {
        if (thisObj.mode.length > 2) {
          switch (thisObj.mode.charAt(2).toLowerCase()) {
            case "s":
              return "s";
              break;
            case "v":
              return "v";
              break;
          }
        }
        return null;
      },

      onDocumentMouseDown: function(e) {
        if (!e) {
          e = window.event;
        }
        var target = e.target || e.srcElement;

        if (target._jscLinkedInstance) {
          if (target._jscLinkedInstance.showOnClick) {
            target._jscLinkedInstance.show();
          }
        } else if (target._jscControlName) {
          jsc.onControlPointerStart(e, target, target._jscControlName, "mouse");
        } else {
          // Mouse is outside the picker controls -> hide the color picker!
          if (jsc.picker && jsc.picker.owner) {
            jsc.picker.owner.hide();
          }
        }
      },

      onDocumentTouchStart: function(e) {
        if (!e) {
          e = window.event;
        }
        var target = e.target || e.srcElement;

        if (target._jscLinkedInstance) {
          if (target._jscLinkedInstance.showOnClick) {
            target._jscLinkedInstance.show();
          }
        } else if (target._jscControlName) {
          jsc.onControlPointerStart(e, target, target._jscControlName, "touch");
        } else {
          if (jsc.picker && jsc.picker.owner) {
            jsc.picker.owner.hide();
          }
        }
      },

      onWindowResize: function(e) {
        jsc.redrawPosition();
      },

      onParentScroll: function(e) {
        // hide the picker when one of the parent elements is scrolled
        if (jsc.picker && jsc.picker.owner) {
          jsc.picker.owner.hide();
        }
      },

      _pointerMoveEvent: {
        mouse: "mousemove",
        touch: "touchmove"
      },
      _pointerEndEvent: {
        mouse: "mouseup",
        touch: "touchend"
      },

      _pointerOrigin: null,
      _capturedTarget: null,

      onControlPointerStart: function(e, target, controlName, pointerType) {
        var thisObj = target._jscInstance;

        jsc.preventDefault(e);
        jsc.captureTarget(target);

        var registerDragEvents = function(doc, offset) {
          jsc.attachGroupEvent(
            "drag",
            doc,
            jsc._pointerMoveEvent[pointerType],
            jsc.onDocumentPointerMove(e, target, controlName, pointerType, offset)
          );
          jsc.attachGroupEvent("drag", doc, jsc._pointerEndEvent[pointerType], jsc.onDocumentPointerEnd(e, target, controlName, pointerType));
        };

        registerDragEvents(document, [0, 0]);

        if (window.parent && window.frameElement) {
          var rect = window.frameElement.getBoundingClientRect();
          var ofs = [-rect.left, -rect.top];
          registerDragEvents(window.parent.window.document, ofs);
        }

        var abs = jsc.getAbsPointerPos(e);
        var rel = jsc.getRelPointerPos(e);
        jsc._pointerOrigin = {
          x: abs.x - rel.x,
          y: abs.y - rel.y
        };

        switch (controlName) {
          case "pad":
            // if the slider is at the bottom, move it up
            switch (jsc.getSliderComponent(thisObj)) {
              case "s":
                if (thisObj.hsv[1] === 0) {
                  thisObj.fromHSV(null, 100, null);
                }
                break;
              case "v":
                if (thisObj.hsv[2] === 0) {
                  thisObj.fromHSV(null, null, 100);
                }
                break;
            }
            jsc.setPad(thisObj, e, 0, 0);
            break;

          case "sld":
            jsc.setSld(thisObj, e, 0);
            break;
        }

        jsc.dispatchFineChange(thisObj);
      },

      onDocumentPointerMove: function(e, target, controlName, pointerType, offset) {
        return function(e) {
          var thisObj = target._jscInstance;
          switch (controlName) {
            case "pad":
              if (!e) {
                e = window.event;
              }
              jsc.setPad(thisObj, e, offset[0], offset[1]);
              jsc.dispatchFineChange(thisObj);
              break;

            case "sld":
              if (!e) {
                e = window.event;
              }
              jsc.setSld(thisObj, e, offset[1]);
              jsc.dispatchFineChange(thisObj);
              break;
          }
        };
      },

      onDocumentPointerEnd: function(e, target, controlName, pointerType) {
        return function(e) {
          var thisObj = target._jscInstance;
          jsc.detachGroupEvents("drag");
          jsc.releaseTarget();
          // Always dispatch changes after detaching outstanding mouse handlers,
          // in case some user interaction will occur in user's onchange callback
          // that would intrude with current mouse events
          jsc.dispatchChange(thisObj);
        };
      },

      dispatchChange: function(thisObj) {
        if (thisObj.valueElement) {
          if (jsc.isElementType(thisObj.valueElement, "input")) {
            jsc.fireEvent(thisObj.valueElement, "change");
          }
        }
      },

      dispatchFineChange: function(thisObj) {
        if (thisObj.onFineChange) {
          var callback;
          if (typeof thisObj.onFineChange === "string") {
            callback = new Function(thisObj.onFineChange);
          } else {
            callback = thisObj.onFineChange;
          }
          callback.call(thisObj);
        }
      },

      setPad: function(thisObj, e, ofsX, ofsY) {
        var pointerAbs = jsc.getAbsPointerPos(e);
        var x = ofsX + pointerAbs.x - jsc._pointerOrigin.x - thisObj.padding - thisObj.insetWidth;
        var y = ofsY + pointerAbs.y - jsc._pointerOrigin.y - thisObj.padding - thisObj.insetWidth;

        var xVal = x * (360 / (thisObj.width - 1));
        var yVal = 100 - y * (100 / (thisObj.height - 1));

        switch (jsc.getPadYComponent(thisObj)) {
          case "s":
            thisObj.fromHSV(xVal, yVal, null, jsc.leaveSld);
            break;
          case "v":
            thisObj.fromHSV(xVal, null, yVal, jsc.leaveSld);
            break;
        }
      },

      setSld: function(thisObj, e, ofsY) {
        var pointerAbs = jsc.getAbsPointerPos(e);
        var y = ofsY + pointerAbs.y - jsc._pointerOrigin.y - thisObj.padding - thisObj.insetWidth;

        var yVal = 100 - y * (100 / (thisObj.height - 1));

        switch (jsc.getSliderComponent(thisObj)) {
          case "s":
            thisObj.fromHSV(null, yVal, null, jsc.leavePad);
            break;
          case "v":
            thisObj.fromHSV(null, null, yVal, jsc.leavePad);
            break;
        }
      },

      _vmlNS: "jsc_vml_",
      _vmlCSS: "jsc_vml_css_",
      _vmlReady: false,

      initVML: function() {
        if (!jsc._vmlReady) {
          // init VML namespace
          var doc = document;
          if (!doc.namespaces[jsc._vmlNS]) {
            doc.namespaces.add(jsc._vmlNS, "urn:schemas-microsoft-com:vml");
          }
          if (!doc.styleSheets[jsc._vmlCSS]) {
            var tags = [
              "shape",
              "shapetype",
              "group",
              "background",
              "path",
              "formulas",
              "handles",
              "fill",
              "stroke",
              "shadow",
              "textbox",
              "textpath",
              "imagedata",
              "line",
              "polyline",
              "curve",
              "rect",
              "roundrect",
              "oval",
              "arc",
              "image"
            ];
            var ss = doc.createStyleSheet();
            ss.owningElement.id = jsc._vmlCSS;
            for (var i = 0; i < tags.length; i += 1) {
              ss.addRule(jsc._vmlNS + "\\:" + tags[i], "behavior:url(#default#VML);");
            }
          }
          jsc._vmlReady = true;
        }
      },

      createPalette: function() {
        var paletteObj = {
          elm: null,
          draw: null
        };

        if (jsc.isCanvasSupported) {
          // Canvas implementation for modern browsers

          var canvas = document.createElement("canvas");
          var ctx = canvas.getContext("2d");

          var drawFunc = function(width, height, type) {
            canvas.width = width;
            canvas.height = height;

            ctx.clearRect(0, 0, canvas.width, canvas.height);

            var hGrad = ctx.createLinearGradient(0, 0, canvas.width, 0);
            hGrad.addColorStop(0 / 6, "#F00");
            hGrad.addColorStop(1 / 6, "#FF0");
            hGrad.addColorStop(2 / 6, "#0F0");
            hGrad.addColorStop(3 / 6, "#0FF");
            hGrad.addColorStop(4 / 6, "#00F");
            hGrad.addColorStop(5 / 6, "#F0F");
            hGrad.addColorStop(6 / 6, "#F00");

            ctx.fillStyle = hGrad;
            ctx.fillRect(0, 0, canvas.width, canvas.height);

            var vGrad = ctx.createLinearGradient(0, 0, 0, canvas.height);
            switch (type.toLowerCase()) {
              case "s":
                vGrad.addColorStop(0, "rgba(255,255,255,0)");
                vGrad.addColorStop(1, "rgba(255,255,255,1)");
                break;
              case "v":
                vGrad.addColorStop(0, "rgba(0,0,0,0)");
                vGrad.addColorStop(1, "rgba(0,0,0,1)");
                break;
            }
            ctx.fillStyle = vGrad;
            ctx.fillRect(0, 0, canvas.width, canvas.height);
          };

          paletteObj.elm = canvas;
          paletteObj.draw = drawFunc;
        } else {
          // VML fallback for IE 7 and 8

          jsc.initVML();

          var vmlContainer = document.createElement("div");
          vmlContainer.style.position = "relative";
          vmlContainer.style.overflow = "hidden";

          var hGrad = document.createElement(jsc._vmlNS + ":fill");
          hGrad.type = "gradient";
          hGrad.method = "linear";
          hGrad.angle = "90";
          hGrad.colors = "16.67% #F0F, 33.33% #00F, 50% #0FF, 66.67% #0F0, 83.33% #FF0";

          var hRect = document.createElement(jsc._vmlNS + ":rect");
          hRect.style.position = "absolute";
          hRect.style.left = -1 + "px";
          hRect.style.top = -1 + "px";
          hRect.stroked = false;
          hRect.appendChild(hGrad);
          vmlContainer.appendChild(hRect);

          var vGrad = document.createElement(jsc._vmlNS + ":fill");
          vGrad.type = "gradient";
          vGrad.method = "linear";
          vGrad.angle = "180";
          vGrad.opacity = "0";

          var vRect = document.createElement(jsc._vmlNS + ":rect");
          vRect.style.position = "absolute";
          vRect.style.left = -1 + "px";
          vRect.style.top = -1 + "px";
          vRect.stroked = false;
          vRect.appendChild(vGrad);
          vmlContainer.appendChild(vRect);

          var drawFunc = function(width, height, type) {
            vmlContainer.style.width = width + "px";
            vmlContainer.style.height = height + "px";

            hRect.style.width = vRect.style.width = width + 1 + "px";
            hRect.style.height = vRect.style.height = height + 1 + "px";

            // Colors must be specified during every redraw, otherwise IE won't display
            // a full gradient during a subsequential redraw
            hGrad.color = "#F00";
            hGrad.color2 = "#F00";

            switch (type.toLowerCase()) {
              case "s":
                vGrad.color = vGrad.color2 = "#FFF";
                break;
              case "v":
                vGrad.color = vGrad.color2 = "#000";
                break;
            }
          };

          paletteObj.elm = vmlContainer;
          paletteObj.draw = drawFunc;
        }

        return paletteObj;
      },

      createSliderGradient: function() {
        var sliderObj = {
          elm: null,
          draw: null
        };

        if (jsc.isCanvasSupported) {
          // Canvas implementation for modern browsers

          var canvas = document.createElement("canvas");
          var ctx = canvas.getContext("2d");

          var drawFunc = function(width, height, color1, color2) {
            canvas.width = width;
            canvas.height = height;

            ctx.clearRect(0, 0, canvas.width, canvas.height);

            var grad = ctx.createLinearGradient(0, 0, 0, canvas.height);
            grad.addColorStop(0, color1);
            grad.addColorStop(1, color2);

            ctx.fillStyle = grad;
            ctx.fillRect(0, 0, canvas.width, canvas.height);
          };

          sliderObj.elm = canvas;
          sliderObj.draw = drawFunc;
        } else {
          // VML fallback for IE 7 and 8

          jsc.initVML();

          var vmlContainer = document.createElement("div");
          vmlContainer.style.position = "relative";
          vmlContainer.style.overflow = "hidden";

          var grad = document.createElement(jsc._vmlNS + ":fill");
          grad.type = "gradient";
          grad.method = "linear";
          grad.angle = "180";

          var rect = document.createElement(jsc._vmlNS + ":rect");
          rect.style.position = "absolute";
          rect.style.left = -1 + "px";
          rect.style.top = -1 + "px";
          rect.stroked = false;
          rect.appendChild(grad);
          vmlContainer.appendChild(rect);

          var drawFunc = function(width, height, color1, color2) {
            vmlContainer.style.width = width + "px";
            vmlContainer.style.height = height + "px";

            rect.style.width = width + 1 + "px";
            rect.style.height = height + 1 + "px";

            grad.color = color1;
            grad.color2 = color2;
          };

          sliderObj.elm = vmlContainer;
          sliderObj.draw = drawFunc;
        }

        return sliderObj;
      },

      leaveValue: 1 << 0,
      leaveStyle: 1 << 1,
      leavePad: 1 << 2,
      leaveSld: 1 << 3,

      BoxShadow: (function() {
        var BoxShadow = function(hShadow, vShadow, blur, spread, color, inset) {
          this.hShadow = hShadow;
          this.vShadow = vShadow;
          this.blur = blur;
          this.spread = spread;
          this.color = color;
          this.inset = !!inset;
        };

        BoxShadow.prototype.toString = function() {
          var vals = [
            Math.round(this.hShadow) + "px",
            Math.round(this.vShadow) + "px",
            Math.round(this.blur) + "px",
            Math.round(this.spread) + "px",
            this.color
          ];
          if (this.inset) {
            vals.push("inset");
          }
          return vals.join(" ");
        };

        return BoxShadow;
      })(),

      //
      // Usage:
      // var myColor = new jscolor(<targetElement> [, <options>])
      //

      jscolor: function(targetElement, options) {
        // General options
        //
        this.value = null; // initial HEX color. To change it later, use methods fromString(), fromHSV() and fromRGB()
        this.valueElement = targetElement; // element that will be used to display and input the color code
        this.styleElement = targetElement; // element that will preview the picked color using CSS backgroundColor
        this.required = true; // whether the associated text <input> can be left empty
        this.refine = true; // whether to refine the entered color code (e.g. uppercase it and remove whitespace)
        this.hash = false; // whether to prefix the HEX color code with # symbol
        this.uppercase = true; // whether to uppercase the color code
        this.onFineChange = null; // called instantly every time the color changes (value can be either a function or a string with javascript code)
        this.activeClass = "jscolor-active"; // class to be set to the target element when a picker window is open on it
        this.minS = 0; // min allowed saturation (0 - 100)
        this.maxS = 100; // max allowed saturation (0 - 100)
        this.minV = 0; // min allowed value (brightness) (0 - 100)
        this.maxV = 100; // max allowed value (brightness) (0 - 100)

        // Accessing the picked color
        //
        this.hsv = [0, 0, 100]; // read-only  [0-360, 0-100, 0-100]
        this.rgb = [255, 255, 255]; // read-only  [0-255, 0-255, 0-255]

        // Color Picker options
        //
        this.width = 181; // width of color palette (in px)
        this.height = 101; // height of color palette (in px)
        this.showOnClick = true; // whether to display the color picker when user clicks on its target element
        this.mode = "HSV"; // HSV | HVS | HS | HV - layout of the color picker controls
        this.position = "bottom"; // left | right | top | bottom - position relative to the target element
        this.smartPosition = true; // automatically change picker position when there is not enough space for it
        this.sliderSize = 16; // px
        this.crossSize = 8; // px
        this.closable = false; // whether to display the Close button
        this.closeText = "Close";
        this.buttonColor = "#000000"; // CSS color
        this.buttonHeight = 18; // px
        this.padding = 12; // px
        this.backgroundColor = "#FFFFFF"; // CSS color
        this.borderWidth = 1; // px
        this.borderColor = "#BBBBBB"; // CSS color
        this.borderRadius = 8; // px
        this.insetWidth = 1; // px
        this.insetColor = "#BBBBBB"; // CSS color
        this.shadow = true; // whether to display shadow
        this.shadowBlur = 15; // px
        this.shadowColor = "rgba(0,0,0,0.2)"; // CSS color
        this.pointerColor = "#4C4C4C"; // px
        this.pointerBorderColor = "#FFFFFF"; // px
        this.pointerBorderWidth = 1; // px
        this.pointerThickness = 2; // px
        this.zIndex = 1000;
        this.container = null; // where to append the color picker (BODY element by default)

        for (var opt in options) {
          if (options.hasOwnProperty(opt)) {
            this[opt] = options[opt];
          }
        }

        this.hide = function() {
          if (isPickerOwner()) {
            detachPicker();
          }
        };

        this.show = function() {
          drawPicker();
        };

        this.redraw = function() {
          if (isPickerOwner()) {
            drawPicker();
          }
        };

        this.importColor = function() {
          if (!this.valueElement) {
            this.exportColor();
          } else {
            if (jsc.isElementType(this.valueElement, "input")) {
              if (!this.refine) {
                if (!this.fromString(this.valueElement.value, jsc.leaveValue)) {
                  if (this.styleElement) {
                    this.styleElement.style.backgroundImage = this.styleElement._jscOrigStyle.backgroundImage;
                    this.styleElement.style.backgroundColor = this.styleElement._jscOrigStyle.backgroundColor;
                    this.styleElement.style.color = this.styleElement._jscOrigStyle.color;
                  }
                  this.exportColor(jsc.leaveValue | jsc.leaveStyle);
                }
              } else if (!this.required && /^\s*$/.test(this.valueElement.value)) {
                this.valueElement.value = "";
                if (this.styleElement) {
                  this.styleElement.style.backgroundImage = this.styleElement._jscOrigStyle.backgroundImage;
                  this.styleElement.style.backgroundColor = this.styleElement._jscOrigStyle.backgroundColor;
                  this.styleElement.style.color = this.styleElement._jscOrigStyle.color;
                }
                this.exportColor(jsc.leaveValue | jsc.leaveStyle);
              } else if (this.fromString(this.valueElement.value)) {
                // managed to import color successfully from the value -> OK, don't do anything
              } else {
                this.exportColor();
              }
            } else {
              // not an input element -> doesn't have any value
              this.exportColor();
            }
          }
        };

        this.exportColor = function(flags) {
          if (!(flags & jsc.leaveValue) && this.valueElement) {
            var value = this.toString();
            if (this.uppercase) {
              value = value.toUpperCase();
            }
            if (this.hash) {
              value = "#" + value;
            }

            if (jsc.isElementType(this.valueElement, "input")) {
              this.valueElement.value = value;
            } else {
              this.valueElement.innerHTML = value;
            }
          }
          if (!(flags & jsc.leaveStyle)) {
            if (this.styleElement) {
              this.styleElement.style.backgroundImage = "none";
              this.styleElement.style.backgroundColor = "#" + this.toString();
              this.styleElement.style.color = this.isLight() ? "#000" : "#FFF";
            }
          }
          if (!(flags & jsc.leavePad) && isPickerOwner()) {
            redrawPad();
          }
          if (!(flags & jsc.leaveSld) && isPickerOwner()) {
            redrawSld();
          }
        };

        // h: 0-360
        // s: 0-100
        // v: 0-100
        //
        this.fromHSV = function(h, s, v, flags) {
          // null = don't change
          if (h !== null) {
            if (isNaN(h)) {
              return false;
            }
            h = Math.max(0, Math.min(360, h));
          }
          if (s !== null) {
            if (isNaN(s)) {
              return false;
            }
            s = Math.max(0, Math.min(100, this.maxS, s), this.minS);
          }
          if (v !== null) {
            if (isNaN(v)) {
              return false;
            }
            v = Math.max(0, Math.min(100, this.maxV, v), this.minV);
          }

          this.rgb = HSV_RGB(
            h === null ? this.hsv[0] : (this.hsv[0] = h),
            s === null ? this.hsv[1] : (this.hsv[1] = s),
            v === null ? this.hsv[2] : (this.hsv[2] = v)
          );

          this.exportColor(flags);
        };

        // r: 0-255
        // g: 0-255
        // b: 0-255
        //
        this.fromRGB = function(r, g, b, flags) {
          // null = don't change
          if (r !== null) {
            if (isNaN(r)) {
              return false;
            }
            r = Math.max(0, Math.min(255, r));
          }
          if (g !== null) {
            if (isNaN(g)) {
              return false;
            }
            g = Math.max(0, Math.min(255, g));
          }
          if (b !== null) {
            if (isNaN(b)) {
              return false;
            }
            b = Math.max(0, Math.min(255, b));
          }

          var hsv = RGB_HSV(r === null ? this.rgb[0] : r, g === null ? this.rgb[1] : g, b === null ? this.rgb[2] : b);
          if (hsv[0] !== null) {
            this.hsv[0] = Math.max(0, Math.min(360, hsv[0]));
          }
          if (hsv[2] !== 0) {
            this.hsv[1] = hsv[1] === null ? null : Math.max(0, this.minS, Math.min(100, this.maxS, hsv[1]));
          }
          this.hsv[2] = hsv[2] === null ? null : Math.max(0, this.minV, Math.min(100, this.maxV, hsv[2]));

          // update RGB according to final HSV, as some values might be trimmed
          var rgb = HSV_RGB(this.hsv[0], this.hsv[1], this.hsv[2]);
          this.rgb[0] = rgb[0];
          this.rgb[1] = rgb[1];
          this.rgb[2] = rgb[2];

          this.exportColor(flags);
        };

        this.fromString = function(str, flags) {
          var m;
          if ((m = str.match(/^\W*([0-9A-F]{3}([0-9A-F]{3})?)\W*$/i))) {
            // HEX notation
            //

            if (m[1].length === 6) {
              // 6-char notation
              this.fromRGB(parseInt(m[1].substr(0, 2), 16), parseInt(m[1].substr(2, 2), 16), parseInt(m[1].substr(4, 2), 16), flags);
            } else {
              // 3-char notation
              this.fromRGB(
                parseInt(m[1].charAt(0) + m[1].charAt(0), 16),
                parseInt(m[1].charAt(1) + m[1].charAt(1), 16),
                parseInt(m[1].charAt(2) + m[1].charAt(2), 16),
                flags
              );
            }
            return true;
          } else if ((m = str.match(/^\W*rgba?\(([^)]*)\)\W*$/i))) {
            var params = m[1].split(",");
            var re = /^\s*(\d*)(\.\d+)?\s*$/;
            var mR, mG, mB;
            if (params.length >= 3 && (mR = params[0].match(re)) && (mG = params[1].match(re)) && (mB = params[2].match(re))) {
              var r = parseFloat((mR[1] || "0") + (mR[2] || ""));
              var g = parseFloat((mG[1] || "0") + (mG[2] || ""));
              var b = parseFloat((mB[1] || "0") + (mB[2] || ""));
              this.fromRGB(r, g, b, flags);
              return true;
            }
          }
          return false;
        };

        this.toString = function() {
          return (
            (0x100 | Math.round(this.rgb[0])).toString(16).substr(1) +
            (0x100 | Math.round(this.rgb[1])).toString(16).substr(1) +
            (0x100 | Math.round(this.rgb[2])).toString(16).substr(1)
          );
        };

        this.toHEXString = function() {
          return "#" + this.toString().toUpperCase();
        };

        this.toRGBString = function() {
          return "rgb(" + Math.round(this.rgb[0]) + "," + Math.round(this.rgb[1]) + "," + Math.round(this.rgb[2]) + ")";
        };

        this.isLight = function() {
          return 0.213 * this.rgb[0] + 0.715 * this.rgb[1] + 0.072 * this.rgb[2] > 255 / 2;
        };

        this._processParentElementsInDOM = function() {
          if (this._linkedElementsProcessed) {
            return;
          }
          this._linkedElementsProcessed = true;

          var elm = this.targetElement;
          do {
            // If the target element or one of its parent nodes has fixed position,
            // then use fixed positioning instead
            //
            // Note: In Firefox, getComputedStyle returns null in a hidden iframe,
            // that's why we need to check if the returned style object is non-empty
            var currStyle = jsc.getStyle(elm);
            if (currStyle && currStyle.position.toLowerCase() === "fixed") {
              this.fixed = true;
            }

            if (elm !== this.targetElement) {
              // Ensure to attach onParentScroll only once to each parent element
              // (multiple targetElements can share the same parent nodes)
              //
              // Note: It's not just offsetParents that can be scrollable,
              // that's why we loop through all parent nodes
              if (!elm._jscEventsAttached) {
                jsc.attachEvent(elm, "scroll", jsc.onParentScroll);
                elm._jscEventsAttached = true;
              }
            }
          } while ((elm = elm.parentNode) && !jsc.isElementType(elm, "body"));
        };

        // r: 0-255
        // g: 0-255
        // b: 0-255
        //
        // returns: [ 0-360, 0-100, 0-100 ]
        //
        function RGB_HSV(r, g, b) {
          r /= 255;
          g /= 255;
          b /= 255;
          var n = Math.min(Math.min(r, g), b);
          var v = Math.max(Math.max(r, g), b);
          var m = v - n;
          if (m === 0) {
            return [null, 0, 100 * v];
          }
          var h = r === n ? 3 + (b - g) / m : g === n ? 5 + (r - b) / m : 1 + (g - r) / m;
          return [60 * (h === 6 ? 0 : h), 100 * (m / v), 100 * v];
        }

        // h: 0-360
        // s: 0-100
        // v: 0-100
        //
        // returns: [ 0-255, 0-255, 0-255 ]
        //
        function HSV_RGB(h, s, v) {
          var u = 255 * (v / 100);

          if (h === null) {
            return [u, u, u];
          }

          h /= 60;
          s /= 100;

          var i = Math.floor(h);
          var f = i % 2 ? h - i : 1 - (h - i);
          var m = u * (1 - s);
          var n = u * (1 - s * f);
          switch (i) {
            case 6:
            case 0:
              return [u, n, m];
            case 1:
              return [n, u, m];
            case 2:
              return [m, u, n];
            case 3:
              return [m, n, u];
            case 4:
              return [n, m, u];
            case 5:
              return [u, m, n];
          }
        }

        function detachPicker() {
          jsc.unsetClass(THIS.targetElement, THIS.activeClass);
          jsc.picker.wrap.parentNode.removeChild(jsc.picker.wrap);
          delete jsc.picker.owner;
        }

        function drawPicker() {
          // At this point, when drawing the picker, we know what the parent elements are
          // and we can do all related DOM operations, such as registering events on them
          // or checking their positioning
          THIS._processParentElementsInDOM();

          if (!jsc.picker) {
            jsc.picker = {
              owner: null,
              wrap: document.createElement("div"),
              box: document.createElement("div"),
              boxS: document.createElement("div"), // shadow area
              boxB: document.createElement("div"), // border
              pad: document.createElement("div"),
              padB: document.createElement("div"), // border
              padM: document.createElement("div"), // mouse/touch area
              padPal: jsc.createPalette(),
              cross: document.createElement("div"),
              crossBY: document.createElement("div"), // border Y
              crossBX: document.createElement("div"), // border X
              crossLY: document.createElement("div"), // line Y
              crossLX: document.createElement("div"), // line X
              sld: document.createElement("div"),
              sldB: document.createElement("div"), // border
              sldM: document.createElement("div"), // mouse/touch area
              sldGrad: jsc.createSliderGradient(),
              sldPtrS: document.createElement("div"), // slider pointer spacer
              sldPtrIB: document.createElement("div"), // slider pointer inner border
              sldPtrMB: document.createElement("div"), // slider pointer middle border
              sldPtrOB: document.createElement("div"), // slider pointer outer border
              btn: document.createElement("div"),
              btnT: document.createElement("span") // text
            };

            jsc.picker.pad.appendChild(jsc.picker.padPal.elm);
            jsc.picker.padB.appendChild(jsc.picker.pad);
            jsc.picker.cross.appendChild(jsc.picker.crossBY);
            jsc.picker.cross.appendChild(jsc.picker.crossBX);
            jsc.picker.cross.appendChild(jsc.picker.crossLY);
            jsc.picker.cross.appendChild(jsc.picker.crossLX);
            jsc.picker.padB.appendChild(jsc.picker.cross);
            jsc.picker.box.appendChild(jsc.picker.padB);
            jsc.picker.box.appendChild(jsc.picker.padM);

            jsc.picker.sld.appendChild(jsc.picker.sldGrad.elm);
            jsc.picker.sldB.appendChild(jsc.picker.sld);
            jsc.picker.sldB.appendChild(jsc.picker.sldPtrOB);
            jsc.picker.sldPtrOB.appendChild(jsc.picker.sldPtrMB);
            jsc.picker.sldPtrMB.appendChild(jsc.picker.sldPtrIB);
            jsc.picker.sldPtrIB.appendChild(jsc.picker.sldPtrS);
            jsc.picker.box.appendChild(jsc.picker.sldB);
            jsc.picker.box.appendChild(jsc.picker.sldM);

            jsc.picker.btn.appendChild(jsc.picker.btnT);
            jsc.picker.box.appendChild(jsc.picker.btn);

            jsc.picker.boxB.appendChild(jsc.picker.box);
            jsc.picker.wrap.appendChild(jsc.picker.boxS);
            jsc.picker.wrap.appendChild(jsc.picker.boxB);
          }

          var p = jsc.picker;

          var displaySlider = !!jsc.getSliderComponent(THIS);
          var dims = jsc.getPickerDims(THIS);
          var crossOuterSize = 2 * THIS.pointerBorderWidth + THIS.pointerThickness + 2 * THIS.crossSize;
          var padToSliderPadding = jsc.getPadToSliderPadding(THIS);
          var borderRadius = Math.min(THIS.borderRadius, Math.round(THIS.padding * Math.PI)); // px
          var padCursor = "crosshair";

          // wrap
          p.wrap.style.clear = "both";
          p.wrap.style.width = dims[0] + 2 * THIS.borderWidth + "px";
          p.wrap.style.height = dims[1] + 2 * THIS.borderWidth + "px";
          p.wrap.style.zIndex = THIS.zIndex;

          // picker
          p.box.style.width = dims[0] + "px";
          p.box.style.height = dims[1] + "px";

          p.boxS.style.position = "absolute";
          p.boxS.style.left = "0";
          p.boxS.style.top = "0";
          p.boxS.style.width = "100%";
          p.boxS.style.height = "100%";
          jsc.setBorderRadius(p.boxS, borderRadius + "px");

          // picker border
          p.boxB.style.position = "relative";
          p.boxB.style.border = THIS.borderWidth + "px solid";
          p.boxB.style.borderColor = THIS.borderColor;
          p.boxB.style.background = THIS.backgroundColor;
          jsc.setBorderRadius(p.boxB, borderRadius + "px");

          // IE hack:
          // If the element is transparent, IE will trigger the event on the elements under it,
          // e.g. on Canvas or on elements with border
          p.padM.style.background = p.sldM.style.background = "#FFF";
          jsc.setStyle(p.padM, "opacity", "0");
          jsc.setStyle(p.sldM, "opacity", "0");

          // pad
          p.pad.style.position = "relative";
          p.pad.style.width = THIS.width + "px";
          p.pad.style.height = THIS.height + "px";

          // pad palettes (HSV and HVS)
          p.padPal.draw(THIS.width, THIS.height, jsc.getPadYComponent(THIS));

          // pad border
          p.padB.style.position = "absolute";
          p.padB.style.left = THIS.padding + "px";
          p.padB.style.top = THIS.padding + "px";
          p.padB.style.border = THIS.insetWidth + "px solid";
          p.padB.style.borderColor = THIS.insetColor;

          // pad mouse area
          p.padM._jscInstance = THIS;
          p.padM._jscControlName = "pad";
          p.padM.style.position = "absolute";
          p.padM.style.left = "0";
          p.padM.style.top = "0";
          p.padM.style.width = THIS.padding + 2 * THIS.insetWidth + THIS.width + padToSliderPadding / 2 + "px";
          p.padM.style.height = dims[1] + "px";
          p.padM.style.cursor = padCursor;

          // pad cross
          p.cross.style.position = "absolute";
          p.cross.style.left = p.cross.style.top = "0";
          p.cross.style.width = p.cross.style.height = crossOuterSize + "px";

          // pad cross border Y and X
          p.crossBY.style.position = p.crossBX.style.position = "absolute";
          p.crossBY.style.background = p.crossBX.style.background = THIS.pointerBorderColor;
          p.crossBY.style.width = p.crossBX.style.height = 2 * THIS.pointerBorderWidth + THIS.pointerThickness + "px";
          p.crossBY.style.height = p.crossBX.style.width = crossOuterSize + "px";
          p.crossBY.style.left = p.crossBX.style.top =
            Math.floor(crossOuterSize / 2) - Math.floor(THIS.pointerThickness / 2) - THIS.pointerBorderWidth + "px";
          p.crossBY.style.top = p.crossBX.style.left = "0";

          // pad cross line Y and X
          p.crossLY.style.position = p.crossLX.style.position = "absolute";
          p.crossLY.style.background = p.crossLX.style.background = THIS.pointerColor;
          p.crossLY.style.height = p.crossLX.style.width = crossOuterSize - 2 * THIS.pointerBorderWidth + "px";
          p.crossLY.style.width = p.crossLX.style.height = THIS.pointerThickness + "px";
          p.crossLY.style.left = p.crossLX.style.top = Math.floor(crossOuterSize / 2) - Math.floor(THIS.pointerThickness / 2) + "px";
          p.crossLY.style.top = p.crossLX.style.left = THIS.pointerBorderWidth + "px";

          // slider
          p.sld.style.overflow = "hidden";
          p.sld.style.width = THIS.sliderSize + "px";
          p.sld.style.height = THIS.height + "px";

          // slider gradient
          p.sldGrad.draw(THIS.sliderSize, THIS.height, "#000", "#000");

          // slider border
          p.sldB.style.display = displaySlider ? "block" : "none";
          p.sldB.style.position = "absolute";
          p.sldB.style.right = THIS.padding + "px";
          p.sldB.style.top = THIS.padding + "px";
          p.sldB.style.border = THIS.insetWidth + "px solid";
          p.sldB.style.borderColor = THIS.insetColor;

          // slider mouse area
          p.sldM._jscInstance = THIS;
          p.sldM._jscControlName = "sld";
          p.sldM.style.display = displaySlider ? "block" : "none";
          p.sldM.style.position = "absolute";
          p.sldM.style.right = "0";
          p.sldM.style.top = "0";
          p.sldM.style.width = THIS.sliderSize + padToSliderPadding / 2 + THIS.padding + 2 * THIS.insetWidth + "px";
          p.sldM.style.height = dims[1] + "px";
          p.sldM.style.cursor = "default";

          // slider pointer inner and outer border
          p.sldPtrIB.style.border = p.sldPtrOB.style.border = THIS.pointerBorderWidth + "px solid " + THIS.pointerBorderColor;

          // slider pointer outer border
          p.sldPtrOB.style.position = "absolute";
          p.sldPtrOB.style.left = -(2 * THIS.pointerBorderWidth + THIS.pointerThickness) + "px";
          p.sldPtrOB.style.top = "0";

          // slider pointer middle border
          p.sldPtrMB.style.border = THIS.pointerThickness + "px solid " + THIS.pointerColor;

          // slider pointer spacer
          p.sldPtrS.style.width = THIS.sliderSize + "px";
          p.sldPtrS.style.height = sliderPtrSpace + "px";

          // the Close button
          function setBtnBorder() {
            var insetColors = THIS.insetColor.split(/\s+/);
            var outsetColor =
              insetColors.length < 2 ? insetColors[0] : insetColors[1] + " " + insetColors[0] + " " + insetColors[0] + " " + insetColors[1];
            p.btn.style.borderColor = outsetColor;
          }
          p.btn.style.display = THIS.closable ? "block" : "none";
          p.btn.style.position = "absolute";
          p.btn.style.left = THIS.padding + "px";
          p.btn.style.bottom = THIS.padding + "px";
          p.btn.style.padding = "0 15px";
          p.btn.style.height = THIS.buttonHeight + "px";
          p.btn.style.border = THIS.insetWidth + "px solid";
          setBtnBorder();
          p.btn.style.color = THIS.buttonColor;
          p.btn.style.font = "12px sans-serif";
          p.btn.style.textAlign = "center";
          try {
            p.btn.style.cursor = "pointer";
          } catch (eOldIE) {
            p.btn.style.cursor = "hand";
          }
          p.btn.onmousedown = function() {
            THIS.hide();
          };
          p.btnT.style.lineHeight = THIS.buttonHeight + "px";
          p.btnT.innerHTML = "";
          p.btnT.appendChild(document.createTextNode(THIS.closeText));

          // place pointers
          redrawPad();
          redrawSld();

          // If we are changing the owner without first closing the picker,
          // make sure to first deal with the old owner
          if (jsc.picker.owner && jsc.picker.owner !== THIS) {
            jsc.unsetClass(jsc.picker.owner.targetElement, THIS.activeClass);
          }

          // Set the new picker owner
          jsc.picker.owner = THIS;

          // The redrawPosition() method needs picker.owner to be set, that's why we call it here,
          // after setting the owner
          if (jsc.isElementType(container, "body")) {
            jsc.redrawPosition();
          } else {
            jsc._drawPosition(THIS, 0, 0, "relative", false);
          }

          if (p.wrap.parentNode != container) {
            container.appendChild(p.wrap);
          }

          jsc.setClass(THIS.targetElement, THIS.activeClass);
        }

        function redrawPad() {
          // redraw the pad pointer
          switch (jsc.getPadYComponent(THIS)) {
            case "s":
              var yComponent = 1;
              break;
            case "v":
              var yComponent = 2;
              break;
          }
          var x = Math.round(THIS.hsv[0] / 360 * (THIS.width - 1));
          var y = Math.round((1 - THIS.hsv[yComponent] / 100) * (THIS.height - 1));
          var crossOuterSize = 2 * THIS.pointerBorderWidth + THIS.pointerThickness + 2 * THIS.crossSize;
          var ofs = -Math.floor(crossOuterSize / 2);
          jsc.picker.cross.style.left = x + ofs + "px";
          jsc.picker.cross.style.top = y + ofs + "px";

          // redraw the slider
          switch (jsc.getSliderComponent(THIS)) {
            case "s":
              var rgb1 = HSV_RGB(THIS.hsv[0], 100, THIS.hsv[2]);
              var rgb2 = HSV_RGB(THIS.hsv[0], 0, THIS.hsv[2]);
              var color1 = "rgb(" + Math.round(rgb1[0]) + "," + Math.round(rgb1[1]) + "," + Math.round(rgb1[2]) + ")";
              var color2 = "rgb(" + Math.round(rgb2[0]) + "," + Math.round(rgb2[1]) + "," + Math.round(rgb2[2]) + ")";
              jsc.picker.sldGrad.draw(THIS.sliderSize, THIS.height, color1, color2);
              break;
            case "v":
              var rgb = HSV_RGB(THIS.hsv[0], THIS.hsv[1], 100);
              var color1 = "rgb(" + Math.round(rgb[0]) + "," + Math.round(rgb[1]) + "," + Math.round(rgb[2]) + ")";
              var color2 = "#000";
              jsc.picker.sldGrad.draw(THIS.sliderSize, THIS.height, color1, color2);
              break;
          }
        }

        function redrawSld() {
          var sldComponent = jsc.getSliderComponent(THIS);
          if (sldComponent) {
            // redraw the slider pointer
            switch (sldComponent) {
              case "s":
                var yComponent = 1;
                break;
              case "v":
                var yComponent = 2;
                break;
            }
            var y = Math.round((1 - THIS.hsv[yComponent] / 100) * (THIS.height - 1));
            jsc.picker.sldPtrOB.style.top = y - (2 * THIS.pointerBorderWidth + THIS.pointerThickness) - Math.floor(sliderPtrSpace / 2) + "px";
          }
        }

        function isPickerOwner() {
          return jsc.picker && jsc.picker.owner === THIS;
        }

        function blurValue() {
          THIS.importColor();
        }

        // Find the target element
        if (typeof targetElement === "string") {
          var id = targetElement;
          var elm = document.getElementById(id);
          if (elm) {
            this.targetElement = elm;
          } else {
            jsc.warn("Could not find target element with ID '" + id + "'");
          }
        } else if (targetElement) {
          this.targetElement = targetElement;
        } else {
          jsc.warn("Invalid target element: '" + targetElement + "'");
        }

        if (this.targetElement._jscLinkedInstance) {
          jsc.warn("Cannot link jscolor twice to the same element. Skipping.");
          return;
        }
        this.targetElement._jscLinkedInstance = this;

        // Find the value element
        this.valueElement = jsc.fetchElement(this.valueElement);
        // Find the style element
        this.styleElement = jsc.fetchElement(this.styleElement);

        var THIS = this;
        var container = this.container ? jsc.fetchElement(this.container) : document.getElementsByTagName("body")[0];
        var sliderPtrSpace = 3; // px

        // For BUTTON elements it's important to stop them from sending the form when clicked
        // (e.g. in Safari)
        if (jsc.isElementType(this.targetElement, "button")) {
          if (this.targetElement.onclick) {
            var origCallback = this.targetElement.onclick;
            this.targetElement.onclick = function(evt) {
              origCallback.call(this, evt);
              return false;
            };
          } else {
            this.targetElement.onclick = function() {
              return false;
            };
          }
        }

        /*
		var elm = this.targetElement;
		do {
			// If the target element or one of its offsetParents has fixed position,
			// then use fixed positioning instead
			//
			// Note: In Firefox, getComputedStyle returns null in a hidden iframe,
			// that's why we need to check if the returned style object is non-empty
			var currStyle = jsc.getStyle(elm);
			if (currStyle && currStyle.position.toLowerCase() === 'fixed') {
				this.fixed = true;
			}

			if (elm !== this.targetElement) {
				// attach onParentScroll so that we can recompute the picker position
				// when one of the offsetParents is scrolled
				if (!elm._jscEventsAttached) {
					jsc.attachEvent(elm, 'scroll', jsc.onParentScroll);
					elm._jscEventsAttached = true;
				}
			}
		} while ((elm = elm.offsetParent) && !jsc.isElementType(elm, 'body'));
		*/

        // valueElement
        if (this.valueElement) {
          if (jsc.isElementType(this.valueElement, "input")) {
            var updateField = function() {
              THIS.fromString(THIS.valueElement.value, jsc.leaveValue);
              jsc.dispatchFineChange(THIS);
            };
            jsc.attachEvent(this.valueElement, "keyup", updateField);
            jsc.attachEvent(this.valueElement, "input", updateField);
            jsc.attachEvent(this.valueElement, "blur", blurValue);
            this.valueElement.setAttribute("autocomplete", "off");
          }
        }

        // styleElement
        if (this.styleElement) {
          this.styleElement._jscOrigStyle = {
            backgroundImage: this.styleElement.style.backgroundImage,
            backgroundColor: this.styleElement.style.backgroundColor,
            color: this.styleElement.style.color
          };
        }

        if (this.value) {
          // Try to set the color from the .value option and if unsuccessful,
          // export the current color
          this.fromString(this.value) || this.exportColor();
        } else {
          this.importColor();
        }
      }
    };

    //================================
    // Public properties and methods
    //================================

    // By default, search for all elements with class="jscolor" and install a color picker on them.
    //
    // You can change what class name will be looked for by setting the property jscolor.lookupClass
    // anywhere in your HTML document. To completely disable the automatic lookup, set it to null.
    //
    jsc.jscolor.lookupClass = "jscolor";

    jsc.jscolor.installByClassName = function(className) {
      var inputElms = document.getElementsByTagName("input");
      var buttonElms = document.getElementsByTagName("button");

      jsc.tryInstallOnElements(inputElms, className);
      jsc.tryInstallOnElements(buttonElms, className);
    };

    jsc.register();

    return jsc.jscolor;
  })();
}
